home *** CD-ROM | disk | FTP | other *** search
/ ETO Development Tools 1 / ETO Development Tools 1.iso / Tools - Objects / MacApp / Unsupported Samples / CRC Cards / Source / UMyViews.inc1.p < prev    next >
Encoding:
Text File  |  1990-07-12  |  50.7 KB  |  1,913 lines  |  [TEXT/MPS ]
  1. (***************************)
  2. (* methods for TDesignView *)
  3. (***************************)
  4. {$S ARes}
  5. FUNCTION TDesignView.GetDocument: TDesignDocument;
  6.  
  7.     BEGIN
  8.         GetDocument:= fDesignDocument;
  9.     END;    {TDesignView.GetDocument}
  10.     
  11. {$S ARes}
  12. PROCEDURE TDesignView.SetDocument(theDesign:TDesignDocument);
  13.  
  14.     BEGIN
  15.         fDesignDocument:= theDesign;
  16.     END;    {TDesignView.SetDocument}
  17.     
  18. {$S ARes}
  19. FUNCTION TDesignView.GetSimpleViewList: TList;
  20.  
  21.     BEGIN
  22.         GetSimpleViewList:= fSimpleViewList;
  23.     END;    {TDesignView.GetSimpleViewList}
  24.     
  25. {$S ARes}
  26. PROCEDURE TDesignView.SetSimpleViewList(theSimpleViewList:TList);
  27.  
  28.     BEGIN
  29.         fSimpleViewList:= theSimpleViewList;
  30.     END;    {TDesignView.SetSimpleViewList}
  31.     
  32. {$S AOpen}
  33. PROCEDURE TDesignView.IRes(itsDocument: TDocument; 
  34.                                                      itsSuperView: TView; VAR itsParams: Ptr); OVERRIDE;
  35.     
  36.     VAR
  37.         aList: TList;
  38.         
  39.     BEGIN
  40.         INHERITED IRes(itsDocument, itsSuperView, itsParams);
  41.         aList:= NewList;
  42.         SELF.SetSimpleViewList(aList);
  43.         SELF.SetDocument(TDesignDocument(itsDocument));
  44.     END;    {TDesignView.IRes}
  45.     
  46. {$S ARes}
  47. PROCEDURE TDesignView.CalcMinSize(VAR minSize: VPoint); OVERRIDE;
  48.  
  49.     VAR
  50.         maxH,
  51.         maxV: LONGINT;
  52.         
  53.     PROCEDURE CalcMaxs(theSimpleView: TSimpleView);
  54.     
  55.         VAR
  56.             theFrame: VRect;
  57.     
  58.         BEGIN
  59.             theSimpleView.GetFrame(theFrame);
  60.             IF theFrame.right > maxH THEN
  61.                 maxH:= theFrame.right;
  62.             IF theFrame.bottom > maxV THEN
  63.                 maxV:= theFrame.bottom;
  64.         END;    {CalcMaxs}
  65.  
  66.     BEGIN
  67.         maxH:= 10;    { the view is sizeFillPage, so if we start with }
  68.         maxV:= 10;    { something, it will be rounded up to full pages }
  69.         fSimpleViewList.Each(CalcMaxs);
  70.         minSize.h:= maxH;
  71.         minSize.v:= maxV;
  72.     END;    {TDesignView.CalcMinSize}
  73.     
  74. {$S ASelCommand}
  75. FUNCTION TDesignView.MakeAddCardCmd(theVPoint: VPoint): TAddCardCommand;
  76.     
  77.     VAR
  78.         aNewCardCmd: TAddCardCommand;
  79.         theDocument: TDesignDocument;
  80.         
  81.     BEGIN
  82.         NEW(aNewCardCmd);
  83.         FailNil(aNewCardCmd);
  84.         theDocument:= SELF.GetDocument;
  85.         aNewCardCmd.IAddCardCommand(theVPoint, theDocument);
  86.         MakeAddCardCmd:= aNewCardCmd;
  87.     END;    {TDesignView.MakeAddCardCmd}
  88.     
  89. {$S ASelCommand}
  90. FUNCTION TDesignView.MakeDeleteCardCmd: TDeleteCardCommand;
  91.  
  92.     VAR
  93.         aDeleteCardCmd: TDeleteCardCommand;
  94.         theCard: TCard;
  95.         theIndex: ArrayIndex;
  96.  
  97.     BEGIN
  98.         NEW(aDeleteCardCmd);
  99.         FailNIL(aDeleteCardCmd);
  100.         theCard:= fDesignDocument.GetCurrentCard;
  101.         theIndex:= fDesignDocument.GetIndexOfCard(theCard);
  102.         aDeleteCardCmd.IDeleteCardCommand(theCard, theIndex);
  103.         MakeDeleteCardCmd:= aDeleteCardCmd;
  104.     END;    {TDesignView.MakeDeleteCardCmd}
  105.     
  106. {$S ASelCommand}
  107. FUNCTION TDesignView.DoMouseCommand(VAR theMouse: Point; VAR info: EventInfo;
  108.                         VAR hysteresis: Point): TCommand; OVERRIDE;
  109.     
  110.     VAR
  111.         disPlacement,                {this is hardwired to the size of TSimpleView -- YUK!!!}
  112.         theVPoint: VPoint;
  113.         
  114.     BEGIN
  115.         DoMouseCommand:= gNoChanges;
  116.         CASE info.theClickCount OF
  117.             kOneClick:
  118.                 IF info.theCmdKey THEN
  119.                     BEGIN
  120.                         SetVPt(disPlacement, -53, -20);
  121.                         PtToVPt(theMouse, theVPoint);
  122.                         AddVPt(disPlacement, theVPoint);
  123.                         IF theVPoint.h < 0 THEN
  124.                             theVPoint.h:= 0;
  125.                         IF theVPoint.v < 0 THEN
  126.                             theVPoint.v:= 0;
  127.                         DoMouseCommand:= SELF.MakeAddCardCmd(theVPoint);
  128.                     END
  129.                 ELSE
  130.                     fDesignDocument.SetCurrentCard(NIL);
  131.             OTHERWISE
  132.                 {do nothing};
  133.         END;    {CASE}
  134.     END;    {TDesignView.DoMouseCommand}
  135.  
  136. {$S ASelCommand}
  137. FUNCTION  TDesignView.DoMenuCommand(aCmdNumber: CmdNumber):TCommand;OVERRIDE;
  138.  
  139.     VAR
  140.         theVPoint: VPoint;
  141.         theCard: TCard;
  142.         theSimpleView: TSimpleView;
  143.         ourScroller: TScroller;
  144.         theTranslation: VPoint;
  145.  
  146.     BEGIN
  147.         DoMenuCommand:= gNoChanges;
  148.         CASE aCmdNumber OF
  149.             cEditCardCmd:
  150.                 BEGIN
  151.                     theCard:= fDesignDocument.GetCurrentCard;
  152.                     theSimpleView:= theCard.GetSimpleView;
  153.                     theSimpleView.OpenEditView;
  154.                 END;
  155.             cDeleteCardCmd:    DoMenuCommand:= SELF.MakeDeleteCardCmd;
  156.             cNewCardCmd:        
  157.                 BEGIN
  158.                     SetVPt(theVPoint, 50, 50);
  159.                     ourScroller:= SELF.GetScroller(kImediateSuperView);
  160.                     theTranslation:= ourScroller.fTranslation;
  161.                     AddVPt(theTranslation, theVPoint);
  162.                     DoMenuCommand:= SELF.MakeAddCardCmd(theVPoint);
  163.                 END;
  164.             OTHERWISE                            {always do this, so other objects get a chance}
  165.                 DoMenuCommand := INHERITED DoMenuCommand(aCmdNumber);
  166.     
  167.             END;  {Case}
  168.     END;    {TDesignView.DoMenuCommand}
  169.     
  170.     {$S ARes}
  171.     PROCEDURE TDesignView.DoSetupMenus; OVERRIDE;
  172.     
  173.     BEGIN
  174.         INHERITED DoSetupMenus;
  175.         IF fDesignDocument.GetNumCards < maxInt THEN
  176.             Enable(cNewCardCmd, TRUE);
  177.         IF fDesignDocument.GetCurrentCard <> NIL THEN
  178.             BEGIN
  179.                 Enable(cEditCardCmd, TRUE);
  180.                 Enable(cDeleteCardCmd, TRUE);
  181.             END;
  182.     END;    {TDesignView.DoSetupMenus}
  183.     
  184.     {$S AClose}
  185.     PROCEDURE TDesignView.Free; OVERRIDE;
  186.     
  187.     BEGIN
  188.         fSimpleViewList.FreeList;
  189.         INHERITED Free;
  190.     END;    {TDesignView.Free}
  191.     
  192.     {$S AFields}
  193.     PROCEDURE TDesignView.Fields(PROCEDURE DoToField(
  194.                     fieldName: Str255; fieldAddr: Ptr; fieldType: INTEGER)); OVERRIDE;
  195.     
  196.     BEGIN
  197.         DoToField('TDesignView', NIL, bClass);
  198.         DoToField('fDesignDocument', @fDesignDocument, bObject);
  199.         DoToField('fSimpleViewList', @fSimpleViewList, bObject);
  200.         INHERITED Fields(DoToField);
  201.     END;   {TDesignView.Fields}
  202.     
  203.     
  204.     (*************************)
  205.     (* methods for TEditView *)
  206.     (*************************)
  207.     
  208.     {$S ARes}
  209.     FUNCTION TEditView.GetCard: TCard;
  210.     
  211.     BEGIN
  212.         GetCard:= fCard;
  213.     END;    {TEditView.GetCard}
  214.     
  215.     {$S ARes}
  216.     PROCEDURE TEditView.SetCard(theCard:TCard);
  217.     
  218.     BEGIN
  219.         fCard:= theCard;
  220.     END;    {TEditView.SetCard}
  221.     
  222.     {$S ARes}
  223.     FUNCTION TEditView.GetFieldEntryView: TEditText;
  224.     
  225.     BEGIN
  226.         GetFieldEntryView:= fFieldEntryItem;
  227.     END;    {TEditView.GetFieldEntryView}
  228.     
  229.     {$S ARes}
  230.     PROCEDURE TEditView.SetFieldEntryView(theEntryView:TEditText);
  231.     
  232.     BEGIN
  233.         fFieldEntryItem:= theEntryView;
  234.     END;    {TEditView.SetFieldEntryView}
  235.     
  236.     {$S ARes}
  237.     FUNCTION TEditView.GetTypeEntryView: TEditText;
  238.     
  239.     BEGIN
  240.         GetTypeEntryView:= fFieldTypeEntryItem;
  241.     END;    {TEditView.GetTypeEntryView}
  242.     
  243.     {$S ARes}
  244.     PROCEDURE TEditView.SetTypeEntryView(theEntryView:TEditText);
  245.     
  246.     BEGIN
  247.         fFieldTypeEntryItem:= theEntryView;
  248.     END;    {TEditView.SetTypeEntryView}
  249.     
  250.     {$S ARes}
  251.     PROCEDURE TEditView.SetOurWindowTitle;
  252.     
  253.     VAR
  254.         ourWindow: TWindow;
  255.         ourNameItem: TItem;
  256.         ourClassName: str255;
  257.     
  258.     BEGIN
  259.         ourWindow:= SELF.GetWindow;
  260.         ourNameItem:= fCard.GetTheClass;
  261.         ourClassName:= ourNameItem.GetTheName;
  262.         ourWindow.SetTitle(ourClassName);
  263.     END;    {TEditView.SetOurWindowTitle}
  264.     
  265.     {$S ARes}
  266.     PROCEDURE TEditView.ChangeOurWindowTitle;
  267.     
  268.     VAR
  269.         theNewTitle: str255;
  270.         theClassItem: TItem;
  271.     
  272.     BEGIN
  273.         fClassNameItem.GetText(theNewTitle);
  274.         theClassItem:= fCard.GetTheClass;
  275.         theClassItem.SetTheName(theNewTitle);
  276.         SELF.SetOurWindowTitle;
  277.     END;    {TEditView.ChangeOurWindowTitle}
  278.     
  279.     {$S ARes}
  280.     PROCEDURE TEditView.SetOurClassName;
  281.     
  282.     VAR
  283.         ourClassName: str255;
  284.         theClassItem: TItem;
  285.     
  286.     BEGIN
  287.         theClassItem:= fCard.GetTheClass;
  288.         ourClassName:= theClassItem.GetTheName;
  289.         fClassNameItem.SetText(ourClassName, true);
  290.         SELF.DoSelectEditText(fClassNameItem, TRUE);
  291.     END;    {TEditView.SetOurClassName}
  292.     
  293.     {$S ARes}
  294.     FUNCTION TEditView.GetOurClassName: str255;
  295.     
  296.     BEGIN
  297.         fClassNameItem.GetText(GetOurClassName);
  298.     END;    {TEditView.GetOurClassName}
  299.     
  300.     {$S ARes}
  301.     PROCEDURE TEditView.SetOurSuperClassName;
  302.     
  303.     VAR
  304.         ourSuperClassName: str255;
  305.         theSuperClassItem: TItem;
  306.     
  307.     BEGIN
  308.         theSuperClassItem:= fCard.GetTheSuperClass;
  309.         ourSuperClassName:= theSuperClassItem.GetTheName;
  310.         fSuperClassNameItem.SetText(ourSuperClassName, true);
  311.     END;    {TEditView.SetOurSuperClassName}
  312.     
  313.     {$S ARes}
  314.     FUNCTION TEditView.GetOurSuperClassName: str255;
  315.     
  316.     BEGIN
  317.         fSuperClassNameItem.GetText(GetOurSuperClassName);
  318.     END;    {TEditView.GetOurSuperClassName}
  319.     
  320.     {$S ARes}
  321.     PROCEDURE TEditView.SetUpOurTextListViews;
  322.     
  323.     VAR
  324.         anItemList: TMyList;
  325.         itsSize: INTEGER;
  326.     
  327.     BEGIN
  328.         anItemList:= fCard.GetFields;
  329.         itsSize:= anItemList.GetSize;
  330.         fFieldTextListView:= TFieldTextListView(SELF.FindSubView(kFieldListID));
  331.         fFieldTextListView.SetItemList(anItemList);
  332.         fFieldTextListView.InsItemLast(itsSize);
  333.         fFieldTextListView.SetEditView(SELF);
  334.         
  335.         anItemList:= fCard.GetMethods;
  336.         itsSize:= anItemList.GetSize;
  337.         fMethodTextListView:= TMethodTextListView(SELF.FindSubView(kMethodListID));
  338.         fMethodTextListView.SetItemList(anItemList);
  339.         fMethodTextListView.InsItemLast(itsSize);
  340.         fMethodTextListView.SetEditView(SELF);
  341.         
  342.         anItemList:= fCard.GetCollaborators;
  343.         itsSize:= anItemList.GetSize;
  344.         fCollaboratorTextListView:= TCollaboratorTextListView(SELF.FindSubView(kCollaboratorListID));
  345.         fCollaboratorTextListView.SetItemList(anItemList);
  346.         fCollaboratorTextListView.InsItemLast(itsSize);
  347.         fCollaboratorTextListView.SetEditView(SELF);
  348.     END;    {TEditView.SetUpOurTextListViews}
  349.     
  350.     {$S ARes}
  351.     PROCEDURE TEditView.SetUpOurEntryViews;
  352.       VAR 
  353.             theCheckBox:TCheckBox;
  354.             fNewFieldButton: TNewFieldButton;
  355.             fNewMethodButton: TNewMethodButton;
  356.             fNewCollaboratorButton: TNewCollaboratorButton;
  357.             
  358.     BEGIN
  359.         fNewFieldButton:= TNewFieldButton(SELF.FindSubView(kFieldButtonID));
  360.         fNewFieldButton.INewButton(SELF);
  361.         fNewMethodButton:= TNewMethodButton(SELF.FindSubView(kMethodButtonID));
  362.         fNewMethodButton.INewButton(SELF);
  363.         fNewCollaboratorButton:= TNewCollaboratorButton(SELF.FindSubView(kCollaboratorButtonID));
  364.         fNewCollaboratorButton.INewButton(SELF);
  365.         fTypeCluster:= TCluster(SELF.FindSubView(kTypeClusterID));
  366.         theCheckBox:= TCheckBox(SELF.FindSubView(kOVERRIDEBoxID));
  367.         SELF.SetOVERRIDEBox(theCheckBox);
  368.         fClassNameItem:= TEditText(SELF.FindSubView(kClassEntryID));
  369.         fSuperClassNameItem:= TEditText(SELF.FindSubView(kSuperClassEntryID));
  370.         fFieldEntryItem:= TEditText(SELF.FindSubView(kFieldEntryID));
  371.         fFieldEntryName:= TStaticText(SELF.FindSubView(kFieldEntryNameID));
  372.         fFieldTypeEntryItem:= TEditText(SELF.FindSubView(kFieldTypeEntryID));
  373.         fFieldTypeEntryName:= TStaticText(SELF.FindSubView(kFieldTypeEntryNameID));
  374.     END;    {TEditView.SetUpOurEntryViews}
  375.     
  376.     {$S ARes}
  377.     PROCEDURE TEditView.StuffFieldTypeEntryItem;
  378.     
  379.     VAR
  380.         typeMenuItemNum: INTEGER;
  381.         theTypeStr: str255;
  382.     
  383.     BEGIN
  384.         CASE fEditMode OF
  385.             kFieldsMode:
  386.                 BEGIN
  387.                     typeMenuItemNum:= fItemTypeMenu.GetCurrentItem;
  388.                     fItemTypeMenu.GetItemText(typeMenuItemNum, theTypeStr);
  389.                     fFieldTypeEntryItem.SetText(theTypeStr, kRedraw);
  390.                     SELF.DoSelectEditText(fFieldTypeEntryItem, TRUE);
  391.                 END;
  392.             kCollaboratorsMode:
  393.                 BEGIN
  394.                     typeMenuItemNum:= fCollaboratorsMenu.GetCurrentItem;
  395.                     fCollaboratorsMenu.GetItemText(typeMenuItemNum, theTypeStr);
  396.                     fFieldEntryItem.SetText(theTypeStr, kRedraw);
  397.                     SELF.DoSelectEditText(fFieldEntryItem, TRUE);
  398.                 END;
  399.             kMethodsMode:
  400.                 BEGIN
  401.                 END;
  402.             END; {CASE}
  403.     END;    {TEditView.StuffFieldTypeEntryItem}
  404.     
  405.     {$S ARes}
  406.     PROCEDURE TEditView.StuffSuperClassEntryItem;
  407.     
  408.     VAR
  409.         typeMenuItemNum: INTEGER;
  410.         theTypeStr: str255;
  411.     
  412.     BEGIN
  413.         typeMenuItemNum:= fSuperClassTypeMenu.GetCurrentItem;
  414.         fSuperClassTypeMenu.GetItemText(typeMenuItemNum, theTypeStr);
  415.         fSuperClassNameItem.SetText(theTypeStr, kRedraw);
  416.         SELF.DoSelectEditText(fSuperClassNameItem, TRUE);
  417.     END;    {TEditView.StuffSuperClassEntryItem}
  418.     
  419.     {$S ARes}
  420.     FUNCTION TEditView.GetOVERRIDEBox: TCheckBox;
  421.     
  422.     BEGIN
  423.         GetOVERRIDEBox:= fOVERRIDEBox;
  424.     END;    {TEditView.GetOVERRIDEBox}
  425.     
  426.     {$S ARes}
  427.     PROCEDURE TEditView.SetOVERRIDEBox(theBox:TCheckBox);
  428.     
  429.     BEGIN
  430.         fOVERRIDEBox:= theBox;
  431.     END;    {TEditView.SetOVERRIDEBox}
  432.     
  433.     {$S ARes}
  434.     PROCEDURE TEditView.SetOVERRIDE(overrideIt:Boolean);
  435.     BEGIN
  436.         fOVERRIDEBox.SetState(overrideIt, kRedraw);
  437.     END;
  438.     
  439.     {$S ARes}
  440.     PROCEDURE TEditView.SetUpFieldsMode;
  441.     BEGIN
  442.         fFieldEntryItem.SetText(kEmptyString, kRedraw);
  443.         fFieldTypeEntryItem.SetText(kEmptyString, kRedraw);
  444.         IF fEditMode <> kFieldsMode THEN
  445.             BEGIN
  446.                 fEditMode:=kFieldsMode;
  447.                 fTypeCluster.SetLabel('Fields',kRedraw);
  448.                 fFieldEntryName.SetText('Field Name:',NOT kRedraw);
  449.                 fFieldTypeEntryName.Show(kVisible,NOT kRedraw);
  450.                 fFieldTypeEntryName.SetText('Field Type:',NOT kRedraw);
  451.                 fItemTypeMenu.ViewEnable(kVisible,NOT kRedraw);
  452.                 fItemTypeMenu.Show(kVisible,NOT kRedraw);
  453.                 fCollaboratorsMenu.ViewEnable(kInvisible,NOT kRedraw);
  454.                 fCollaboratorsMenu.Show(kInvisible,NOT kRedraw);
  455.                 fOVERRIDEBox.ViewEnable(kInvisible,NOT kRedraw);
  456.                 fOVERRIDEBox.Show(kInvisible,NOT kRedraw);
  457.                 fFieldTypeEntryItem.ViewEnable(kVisible,NOT kRedraw);
  458.                 fFieldTypeEntryItem.Show(kVisible,NOT kRedraw);
  459.             END;
  460.         SELF.StuffFieldTypeEntryItem;
  461.         SELF.DoSelectEditText(fFieldEntryItem, TRUE);
  462.     END; {TEditView.SetUpFieldsMode}
  463.     
  464.     {$S ARes}
  465.     PROCEDURE TEditView.SetUpMethodsMode;
  466.     BEGIN
  467.         fFieldEntryItem.SetText(kEmptyString, kRedraw);
  468.         fFieldTypeEntryItem.SetText(kEmptyString, kRedraw);
  469.         IF fEditMode <> kMethodsMode THEN
  470.             BEGIN
  471.                 fEditMode:=kMethodsMode;
  472.                 fTypeCluster.SetLabel('Methods',kRedraw);
  473.                 fFieldEntryName.SetText('Method Name:',NOT kRedraw);
  474.                 fFieldTypeEntryName.Show(kInvisible,NOT kRedraw);
  475.                 fFieldTypeEntryName.SetText('Method Type:',NOT kRedraw);
  476.                 fItemTypeMenu.ViewEnable(kInvisible,NOT kRedraw);
  477.                 fItemTypeMenu.Show(kInvisible,NOT kRedraw);
  478.                 fCollaboratorsMenu.ViewEnable(kInvisible,NOT kRedraw);
  479.                 fCollaboratorsMenu.Show(kInvisible,NOT kRedraw);
  480.                 fOVERRIDEBox.ViewEnable(kVisible,NOT kRedraw);
  481.                 fOVERRIDEBox.Show(kVisible,NOT kRedraw);
  482.                 fFieldTypeEntryItem.ViewEnable(kInvisible,NOT kRedraw);
  483.                 fFieldTypeEntryItem.Show(kInvisible,NOT kRedraw);
  484.             END;
  485.         fOVERRIDEBox.SetState(NOT kControlOn, kRedraw);
  486.         SELF.StuffFieldTypeEntryItem;
  487.         SELF.DoSelectEditText(fFieldEntryItem, TRUE);
  488.     END; {TEditView.SetUpMethodsMode}
  489.     
  490.     {$S ARes}
  491.     PROCEDURE TEditView.SetUpCollaboratorsMode;
  492.     BEGIN
  493.         fFieldEntryItem.SetText(kEmptyString, kRedraw);
  494.         fFieldTypeEntryItem.SetText(kEmptyString, kRedraw);
  495.         IF fEditMode<>kCollaboratorsMode THEN
  496.             BEGIN
  497.                 fEditMode:=kCollaboratorsMode;
  498.                 fTypeCluster.SetLabel('Collaborators',kRedraw);
  499.                 fFieldEntryName.SetText('Collaborator:',NOT kRedraw);
  500.                 fFieldTypeEntryName.Show(kInvisible,NOT kRedraw);
  501.                 fItemTypeMenu.ViewEnable(kInvisible,NOT kRedraw);
  502.                 fItemTypeMenu.Show(kInvisible,NOT kRedraw);
  503.                 fCollaboratorsMenu.ViewEnable(kVisible,NOT kRedraw);
  504.                 fCollaboratorsMenu.Show(kVisible,NOT kRedraw);
  505.                 fOVERRIDEBox.Show(kInvisible,NOT kRedraw);
  506.                 fOVERRIDEBox.ViewEnable(kInvisible,NOT kRedraw);
  507.                 fFieldTypeEntryItem.Show(kInvisible,NOT kRedraw);
  508.                 fFieldTypeEntryItem.ViewEnable(kInvisible,NOT kRedraw);
  509.             END;
  510.         SELF.StuffFieldTypeEntryItem;
  511.         SELF.DoSelectEditText(fFieldEntryItem, TRUE);
  512.     END; {TEditView.SetUpCollaboratorsMode}
  513.     
  514. {$S ADoCommand}
  515. PROCEDURE TEditView.AddCardToObjectLists(theCardToAdd: TCard);
  516.  
  517. VAR
  518.     theClass: Str255;
  519.     theObjectMenu: TPopup;
  520.     
  521.     PROCEDURE AddTheItem(thePopup: TPopup; theItem: Str255);
  522.     
  523.     VAR
  524.         theMenu: MenuHandle;
  525.         itemNumber, currentItemNumber: Integer;
  526.         aString: Str255;
  527.         
  528.     BEGIN
  529.         theMenu:=thePopup.fMenuHandle;
  530.         currentItemNumber:=thePopup.GetCurrentItem;
  531.         itemNumber:=2;
  532.         REPEAT
  533.             itemNumber:=itemNumber+1;
  534.             GetItem(theMenu, itemNumber, aString);
  535.         UNTIL aString=kBlankLine;
  536.         InsMenuItem(theMenu, theItem, itemNumber-1);
  537.         
  538.             {if we inserted before the current item, bump the current item up one}
  539.         IF currentItemNumber>=itemNumber THEN
  540.             thePopup.SetCurrentItem(currentItemNumber + 1, NOT kRedraw);  
  541.     END;
  542.     
  543. BEGIN
  544.     theClass:= theCardToAdd.GetTheClass.GetTheName;
  545.     theObjectMenu:= SELF.fSuperClassTypeMenu;
  546.     AddTheItem(theObjectMenu, theClass);
  547.     theObjectMenu:= SELF.fCollaboratorsMenu;
  548.     AddTheItem(theObjectMenu, theClass);
  549. END; {TEditView.AddCardToObjectLists}
  550.     
  551. {$S ADoCommand}
  552. PROCEDURE TEditView.RemoveCardFromObjectLists(theCardToRemove: TCard);
  553.  
  554. VAR
  555.     theClass: Str255;
  556.     theObjectMenu: TPopup;
  557.     
  558.     PROCEDURE RemoveTheItem(thePopup: TPopup; theItem: Str255);
  559.     
  560.     VAR
  561.         theMenu: MenuHandle;
  562.         itemNumber: Integer;
  563.         aString: Str255;
  564.         
  565.     BEGIN
  566.         theMenu:=thePopup.fMenuHandle;
  567.         itemNumber:=2;
  568.         REPEAT
  569.             itemNumber:=itemNumber+1;
  570.             GetItem(theMenu, itemNumber, aString);
  571.         UNTIL aString=theItem;
  572.         DelMenuItem(theMenu, itemNumber);
  573.     END;
  574.     
  575. BEGIN
  576.     theClass:= theCardToRemove.GetTheClass.GetTheName;
  577.     theObjectMenu:= SELF.fSuperClassTypeMenu;
  578.     RemoveTheItem(theObjectMenu, theClass);
  579.     theObjectMenu:= SELF.fCollaboratorsMenu;
  580.     RemoveTheItem(theObjectMenu, theClass);
  581. END; {TEditView.RemoveCardFromObjectLists}
  582.     
  583. {$S ADoCommand}
  584. PROCEDURE TEditView.ChangeNameInObjectLists(theOldName, theNewName: Str255);
  585. VAR
  586.     theObjectMenu: TPopup;
  587.     
  588.     PROCEDURE ChangeTheItem(thePopup: TPopup);
  589.     
  590.     VAR
  591.         theMenu: MenuHandle;
  592.         itemNumber: Integer;
  593.         aString: Str255;
  594.         
  595.     BEGIN
  596.         theMenu:=thePopup.fMenuHandle;
  597.         itemNumber:=2;
  598.         REPEAT
  599.             itemNumber:=itemNumber+1;
  600.             GetItem(theMenu, itemNumber, aString);
  601.         UNTIL aString=theOldName;
  602.             SetItem(theMenu, itemNumber, theNewName);
  603.     END;
  604.     
  605. BEGIN
  606.     theObjectMenu:= SELF.fSuperClassTypeMenu;
  607.     ChangeTheItem(theObjectMenu);
  608.     theObjectMenu.ForceRedraw;
  609.     theObjectMenu:= SELF.fCollaboratorsMenu;
  610.     ChangeTheItem(theObjectMenu);
  611.     theObjectMenu.ForceRedraw;
  612. END; {TEditView.ChangeNameInObjectLists}
  613.     
  614.     {$S AOpen}
  615.     PROCEDURE TEditView.IEditView(theCard: TCard);
  616.     
  617.     VAR
  618.         theTextHandler: TTextHandler;
  619.         
  620.     BEGIN
  621.         SELF.SetCard(theCard);
  622.         SELF.SetOurWindowTitle;
  623.         SELF.SetUpOurEntryViews;
  624.         SELF.SetUpOurTextListViews;
  625.  
  626.         theTextHandler:=SELF.GetCard.GetTextHandler;
  627.         
  628.         {setup the Type Menu for Methods & Fields}
  629.         fItemTypeMenu:= TPopUp(SELF.FindSubView(kItemTypeMenuID));
  630.         theTextHandler.SetItemTypeMenu(SELF.fItemTypeMenu);
  631.         SELF.StuffFieldTypeEntryItem;
  632.         
  633.         {setup the SuperClass Menu}
  634.         fSuperClassTypeMenu:= TPopUp(SELF.FindSubView(kSuperClassTypeMenuID));
  635.         theTextHandler.SetSuperClassTypeMenu(SELF.fSuperClassTypeMenu);
  636.         SELF.StuffSuperClassEntryItem;
  637.         
  638.         {setup the Collaborators Menu}
  639.         fCollaboratorsMenu:= TPopUp(SELF.FindSubView(kCollaboratorsMenuID));
  640.         theTextHandler.SetCollaboratorsMenu(SELF.fCollaboratorsMenu);
  641.             {don't stuff anything, because it's not shown originally}
  642.             
  643.         SELF.SetOurClassName;
  644.         SELF.SetOurSuperClassName;
  645.         SELF.SetUpFieldsMode;
  646.         SELF.DoSelectEditText(fClassNameItem, TRUE);
  647.     END;    {TEditView.IEditView}
  648.     
  649.     {$S ADoCommand}
  650.     PROCEDURE TEditView.ChangeClassName(theName: str255);
  651.     
  652.     BEGIN
  653.         fClassNameItem.SetText(theName, kReDraw);
  654.         SELF.ChangeOurWindowTitle;
  655.     END;    {TEditView.ChangeClassName}
  656.     
  657.     {$S ADoCommand}
  658.     PROCEDURE TEditView.ChangeSuperClassName(theName: str255);
  659.     
  660.     BEGIN
  661.         fSuperClassNameItem.SetText(theName, kReDraw);
  662.     END;    {TEditView.ChangeSuperClassName}
  663.     
  664.     {$S ASelCommand}
  665.     FUNCTION TEditView.MakeChangeClassCmd: TChangeClassCommand;
  666.     
  667.     VAR
  668.         theItem: TItem;
  669.         theOldName: str255;
  670.         theNewName: str255;
  671.         aChangeClassCmd: TChangeClassCommand;
  672.     
  673.     BEGIN
  674.         theItem:= fCard.GetTheClass;
  675.         theOldName:= theItem.GetTheName;
  676.         fClassNameItem.GetText(theNewName);
  677.         NEW(aChangeClassCmd);
  678.         FailNIL(aChangeClassCmd);
  679.         aChangeClassCmd.IChangeNameCommand(cChangeNameCmd, fCard, theOldName, theNewName);
  680.         MakeChangeClassCmd:= aChangeClassCmd;
  681.     END;    {TEditView.MakeChangeClassCmd}
  682.     
  683.     {$S ASelCommand}
  684.     FUNCTION TEditView.MakeChangeSuperClassCmd: TChangeSuperClassCommand;
  685.     
  686.     VAR
  687.         theItem: TItem;
  688.         theOldName: str255;
  689.         theNewName: str255;
  690.         aChangeSuperClassCmd: TChangeSuperClassCommand;
  691.     
  692.     BEGIN
  693.         theItem:= fCard.GetTheSuperClass;
  694.         theOldName:= theItem.GetTheName;
  695.         fSuperClassNameItem.GetText(theNewName);
  696.         NEW(aChangeSuperClassCmd);
  697.         FailNIL(aChangeSuperClassCmd);
  698.         aChangeSuperClassCmd.IChangeNameCommand(cChangeSuperClassCmd, fCard, theOldName, 
  699.                                                                             theNewName);
  700.         MakeChangeSuperClassCmd:= aChangeSuperClassCmd;
  701.     END;    {TEditView.MakeChangeSuperClassCmd}
  702.     
  703.     {$S ASelCommand}
  704.     FUNCTION TEditView.MakeAddFieldCmd: TAddFieldItemCommand;
  705.     
  706.     VAR
  707.         theItemName: str255;
  708.         theTypeStr: str255;
  709.         anAddFieldCmd: TAddFieldItemCommand;
  710.     
  711.     BEGIN
  712.         fFieldEntryItem.GetText(theItemName);
  713.         fFieldTypeEntryItem.GetText(theTypeStr);
  714.         NEW(anAddFieldCmd);
  715.         FailNIL(anAddFieldCmd);
  716.         anAddFieldCmd.IAddFieldItemCommand(fCard, theItemName, theTypeStr);
  717.         MakeAddFieldCmd:= anAddFieldCmd;
  718.     END;    {TEditView.MakeAddFieldCmd}
  719.     
  720.     {$S ASelCommand}
  721.     FUNCTION TEditView.MakeChangeFieldCmd: TChangeFieldCommand;
  722.     
  723.     VAR
  724.         theItemName: str255;
  725.         theTypeStr: str255;
  726.         theField: TFieldItem;
  727.         theFieldsList: TMyList;
  728.         aChangeFieldCmd: TChangeFieldCommand;
  729.     
  730.     BEGIN
  731.         fFieldEntryItem.GetText(theItemName);
  732.         fFieldTypeEntryItem.GetText(theTypeStr);
  733.         theFieldsList:= fFieldTextListView.GetItemList;
  734.         theField:= TFieldItem(theFieldsList.At(fFieldTextListView.FirstSelectedItem));
  735.         NEW(aChangeFieldCmd);
  736.         FailNIL(aChangeFieldCmd);
  737.         aChangeFieldCmd.IChangeFieldCommand(cChangeFieldCmd, fCard, theField,
  738.                                                                                 theItemName, theTypeStr);
  739.         MakeChangeFieldCmd:= aChangeFieldCmd;
  740.     END;    {TEditView.MakeChangeFieldCmd}
  741.     
  742.     {$S ASelCommand}
  743.     FUNCTION TEditView.MakeAddMethodCmd: TAddMethodItemCommand;
  744.     
  745.     VAR
  746.         makeItAnOverride: boolean;
  747.         theItemName: str255;
  748.         anAddMethodCmd: TAddMethodItemCommand;
  749.     
  750.     BEGIN
  751.         makeItAnOverride:= NOT kOVERRIDE;
  752.         IF fOVERRIDEBox.IsOn THEN
  753.             makeItAnOverride:= kOVERRIDE;
  754.         fFieldEntryItem.GetText(theItemName);
  755.         NEW(anAddMethodCmd);
  756.         FailNIL(anAddMethodCmd);
  757.         anAddMethodCmd.IAddMethodItemCommand(fCard, theItemName, makeItAnOverride);
  758.         MakeAddMethodCmd:= anAddMethodCmd;
  759.     END;    {TEditView.MakeAddMethodCmd}
  760.     
  761.     {$S ASelCommand}
  762.     FUNCTION TEditView.MakeChangeMethodCmd: TChangeMethodCommand;
  763.     
  764.     VAR
  765.         theItemName: str255;
  766.         makeItAnOverride: Boolean;
  767.         theMethod: TMethodItem;
  768.         theMethodsList: TMyList;
  769.         aChangeMethodCommand: TChangeMethodCommand;
  770.     
  771.     BEGIN
  772.         fFieldEntryItem.GetText(theItemName);
  773.         makeItAnOverride:= NOT kOVERRIDE;
  774.         IF fOVERRIDEBox.IsOn THEN
  775.             makeItAnOverride:= kOVERRIDE;
  776.         theMethodsList:= fMethodTextListView.GetItemList;
  777.         theMethod:= TMethodItem(theMethodsList.At
  778.                 (fMethodTextListView.FirstSelectedItem));
  779.         NEW(aChangeMethodCommand);
  780.         FailNIL(aChangeMethodCommand);
  781.         aChangeMethodCommand.IChangeMethodCommand(cChangeMethodCmd, fCard, theMethod,
  782.                                                                                             theItemName, makeItAnOverride);
  783.         MakeChangeMethodCmd:= aChangeMethodCommand;
  784.     END;    {TEditView.MakeChangeMethodCmd}
  785.     
  786.     {$S ASelCommand}
  787.     FUNCTION TEditView.MakeAddCollabCmd: TAddCollaboratorItemCommand;
  788.     
  789.     VAR
  790.         theItemName: str255;
  791.         anAddCollaboratorCmd: TAddCollaboratorItemCommand;
  792.     
  793.     BEGIN
  794.         fFieldEntryItem.GetText(theItemName);
  795.         NEW(anAddCollaboratorCmd);
  796.         FailNIL(anAddCollaboratorCmd);
  797.         anAddCollaboratorCmd.IAddCollaboratorItemCommand(fCard, theItemName);
  798.         MakeAddCollabCmd:= anAddCollaboratorCmd;
  799.     END;    {TEditView.MakeAddCollabCmd}
  800.     
  801.     {$S ASelCommand}
  802.     FUNCTION TEditView.MakeChangeCollaboratorCmd: TChangeCollaboratorCommand;
  803.     
  804.     VAR
  805.         theItemName: str255;
  806.         theCollaborator: TCollaboratorItem;
  807.         theCollaboratorsList: TMyList;
  808.         aChangeCollaboratorCommand: TChangeCollaboratorCommand;
  809.     
  810.     BEGIN
  811.         fFieldEntryItem.GetText(theItemName);
  812.         theCollaboratorsList:= fCollaboratorTextListView.GetItemList;
  813.         theCollaborator:= TCollaboratorItem(theCollaboratorsList.At
  814.                 (fCollaboratorTextListView.FirstSelectedItem));
  815.         NEW(aChangeCollaboratorCommand);
  816.         FailNIL(aChangeCollaboratorCommand);
  817.         aChangeCollaboratorCommand.IChangeCollaboratorCommand(cChangeCollaboratorCmd,
  818.                                                                                                 fCard, theCollaborator, theItemName);
  819.         MakeChangeCollaboratorCmd:= aChangeCollaboratorCommand;
  820.     END;    {TEditView.MakeChangeCollaboratorCmd}
  821.     
  822.     {$S ASelCommand}
  823.     FUNCTION TEditView.MakeDeleteFieldCmd: TDeleteFieldItemCommand;
  824.     
  825.     VAR
  826.         theIndex: ArrayIndex;
  827.         theItem: TFieldItem;
  828.         aDeleteFieldCmd: TDeleteFieldItemCommand;
  829.     
  830.     BEGIN
  831.         theIndex:= fFieldTextListView.FirstSelectedItem;
  832.         theItem:= fCard.GetFieldItemAtIndex(theIndex);
  833.         NEW(aDeleteFieldCmd);
  834.         FailNIL(aDeleteFieldCmd);
  835.         aDeleteFieldCmd.IDeleteFieldItemCommand(fCard, theItem, theIndex);
  836.         MakeDeleteFieldCmd:= aDeleteFieldCmd;
  837.     END;    {TEditView.MakeDeleteFieldCmd}
  838.     
  839.     {$S ASelCommand}
  840.     FUNCTION TEditView.MakeDeleteMethodCmd: TDeleteMethodItemCommand;
  841.     
  842.     VAR
  843.         theIndex: ArrayIndex;
  844.         theItem: TMethodItem;
  845.         aDeleteMethodCmd: TDeleteMethodItemCommand;
  846.     
  847.     BEGIN
  848.         theIndex:= fMethodTextListView.FirstSelectedItem;
  849.         theItem:= fCard.GetMethodItemAtIndex(theIndex);
  850.         NEW(aDeleteMethodCmd);
  851.         FailNIL(aDeleteMethodCmd);
  852.         aDeleteMethodCmd.IDeleteMethodItemCommand(fCard, theItem, theIndex);
  853.         MakeDeleteMethodCmd:= aDeleteMethodCmd;
  854.     END;    {TEditView.MakeDeleteMethodCmd}
  855.     
  856.     {$S ASelCommand}
  857.     FUNCTION TEditView.MakeDeleteCollabCmd: TDeleteCollabItemCommand;
  858.     
  859.     VAR
  860.         theIndex: ArrayIndex;
  861.         theItem: TCollaboratorItem;
  862.         aDeleteCollabCmd: TDeleteCollabItemCommand;
  863.     
  864.     BEGIN
  865.         theIndex:= fCollaboratorTextListView.FirstSelectedItem;
  866.         theItem:= fCard.GetCollaboratorItemAtIndex(theIndex);
  867.         NEW(aDeleteCollabCmd);
  868.         FailNIL(aDeleteCollabCmd);
  869.         aDeleteCollabCmd.IDeleteCollabItemCommand(fCard, theItem, theIndex);
  870.         MakeDeleteCollabCmd:= aDeleteCollabCmd;
  871.     END;    {TEditView.MakeDeleteCollabCmd}
  872.     
  873.     {$S ARes}
  874.     FUNCTION TEditView.DoKeyCommand(ch: CHAR; aKeyCode: INTEGER; VAR info: EventInfo)
  875.                     : TCommand; OVERRIDE;
  876.     BEGIN
  877.         IF (ch = chTab) THEN SELF.DoChoice(fCurrentEditText, mEditTabKey);
  878.         IF (ch = chEnter) THEN SELF.DoChoice(fCurrentEditText, mEditEnterKey);
  879.         IF (ch = chReturn) THEN SELF.DoChoice(fCurrentEditText, mEditReturnKey);
  880.         DoKeyCommand:= Inherited DoKeyCommand(ch, aKeyCode, info);
  881.     END;
  882.     
  883.     {$S ASelCommand}
  884.     FUNCTION  TEditView.DoMenuCommand(aCmdNumber: CmdNumber):TCommand;OVERRIDE;
  885.     
  886.     BEGIN
  887.         DoMenuCommand:= gNoChanges;    {in case we don't do anything}
  888.         CASE aCmdNumber OF
  889.             cChangeNameCmd:             DoMenuCommand:= SELF.MakeChangeClassCmd;
  890.             cChangeSuperClassCmd: DoMenuCommand:= SELF.MakeChangeSuperClassCmd;
  891.             cAddFieldCmd:                 DoMenuCommand:= SELF.MakeAddFieldCmd;
  892.             cAddMethodCmd:                 DoMenuCommand:= SELF.MakeAddMethodCmd;
  893.             cAddCollaboratorCmd:     DoMenuCommand:= SELF.MakeAddCollabCmd;
  894.             cDelFieldCmd:                    DoMenuCommand:= SELF.MakeDeleteFieldCmd;
  895.             cDelMethodCmd:                DoMenuCommand:= SELF.MakeDeleteMethodCmd;
  896.             cDelCollaboratorCmd:    DoMenuCommand:= SELF.MakeDeleteCollabCmd;
  897.             OTHERWISE                            {always do this, so other objects get a chance}
  898.                 DoMenuCommand := INHERITED DoMenuCommand(aCmdNumber);
  899.             END;  {Case}
  900.     END;    {TEditView.DoMenuCommand}
  901.     
  902.     {$S ARes}
  903.     PROCEDURE TEditView.DoSetupMenus; OVERRIDE;
  904.     
  905.     VAR
  906.         theTypeStr,
  907.         theEntryItemStr: str255;
  908.         theItem: TItem;
  909.         
  910.     BEGIN
  911.         INHERITED DoSetupMenus;
  912.             
  913.         fClassNameItem.GetText(theEntryItemStr);
  914.         theItem:= fCard.GetTheClass;
  915.         IF theEntryItemStr <> theItem.GetTheName THEN
  916.             ENable(cChangeNameCmd, TRUE);
  917.             
  918.         fSuperClassNameItem.GetText(theEntryItemStr);
  919.         theItem:= fCard.GetTheSuperClass;
  920.         IF theEntryItemStr <> theItem.GetTheName THEN
  921.             Enable(cChangeSuperClassCmd, TRUE);
  922.         
  923.         fFieldEntryItem.GetText(theEntryItemStr);
  924.         IF theEntryItemStr <> kEmptyString THEN
  925.         CASE fEditMode OF
  926.             kFieldsMode:
  927.                 BEGIN
  928.                     fFieldTypeEntryItem.GetText(theTypeStr);
  929.                     IF (theTypeStr <> kEmptyString) THEN
  930.                         Enable(cAddFieldCmd, TRUE);
  931.                 END;
  932.             kMethodsMode:    
  933.                 IF theEntryItemStr <> kEmptyString THEN
  934.                     Enable(cAddMethodCmd, TRUE);
  935.             kCollaboratorsMode:
  936.                 IF theEntryItemStr <> kEmptyString THEN
  937.                     Enable(cAddCollaboratorCmd, TRUE);
  938.         END; {CASE}
  939.         
  940.         IF fFieldTextListView.FirstSelectedItem<> kNoItemSelected THEN
  941.             Enable(cDelFieldCmd, TRUE);;
  942.         IF fMethodTextListView.FirstSelectedItem<> kNoItemSelected THEN
  943.             Enable(cDelMethodCmd, TRUE);;
  944.         IF fCollaboratorTextListView.FirstSelectedItem<> kNoItemSelected THEN
  945.             Enable(cDelCollaboratorCmd, TRUE);
  946.     END;    {TEditView.DoSetupMenus}
  947.     
  948.     {$S ADoCommand}
  949.     PROCEDURE TEditView.AddField(theIndex: ArrayIndex);
  950.     
  951.     BEGIN
  952.         fFieldTextListView.InsItemBefore(theIndex, kOneItem);
  953.     END;    {TEditView.AddField}
  954.     
  955.     {$S ADoCommand}
  956.     PROCEDURE TEditView.AddFieldLast;
  957.     
  958.     BEGIN
  959.         fFieldTextListView.InsItemLast(kOneItem);
  960.     END;    {TEditView.AddFieldLast}
  961.     
  962.     {$S ADoCommand}
  963.     PROCEDURE TEditView.DeleteField(theIndex: INTEGER);
  964.     
  965.     BEGIN
  966.         fFieldTextListView.SelectItem(theIndex, kDontExtendSel, kHiLite, kDontSelect);
  967.         fFieldTextListView.DelItemAt(theIndex, kOneItem);
  968.     END;    {TEditView.DeleteField}
  969.     
  970.     {$S ADoCommand}
  971.     PROCEDURE TEditView.AddMethod;
  972.     
  973.     VAR
  974.         index: integer;
  975.     
  976.     BEGIN
  977.         fMethodTextListView.InsItemLast(kOneItem);
  978.         FOR index:= 1 to fMethodTextListView.GetNumRows DO
  979.             fMethodTextListView.InvalidateItem(index);
  980.     END;    {TEditView.AddMethod}
  981.     
  982.     {$S ADoCommand}
  983.     PROCEDURE TEditView.AddMethodLast;
  984.     
  985.     VAR
  986.         index: ArrayIndex;
  987.     
  988.     BEGIN
  989.         fMethodTextListView.InsItemLast(kOneItem);
  990.         FOR index:= 1 to fMethodTextListView.GetNumRows DO
  991.             fMethodTextListView.InvalidateItem(index);
  992.     END;    {TEditView.AddMethodLast}
  993.     
  994.     {$S ADoCommand}
  995.     PROCEDURE TEditView.DeleteMethod(theIndex: INTEGER);
  996.     
  997.     BEGIN
  998.         fMethodTextListView.SelectItem(theIndex, kDontExtendSel, kHiLite, kDontSelect);
  999.         fMethodTextListView.DelItemAt(theIndex, kOneItem);
  1000.     END;    {TEditView.DeleteMethod}
  1001.     
  1002.     {$S ADoCommand}
  1003.     PROCEDURE TEditView.AddCollaborator(theIndex: ArrayIndex);
  1004.     
  1005.     BEGIN
  1006.         fCollaboratorTextListView.InsItemBefore(theIndex, kOneItem);
  1007.     END;    {TEditView.AddCollaborator}
  1008.     
  1009.     {$S ADoCommand}
  1010.     PROCEDURE TEditView.AddCollaboratorLast;
  1011.     
  1012.     BEGIN
  1013.         fCollaboratorTextListView.InsItemLast(kOneItem);
  1014.     END;    {TEditView.AddCollaboratorLast}
  1015.     
  1016.     {$S ADoCommand}
  1017.     PROCEDURE TEditView.DeleteCollaborator(theIndex: INTEGER);
  1018.     
  1019.     BEGIN
  1020.         fCollaboratorTextListView.SelectItem(theIndex, kDontExtendSel, kHiLite, kDontSelect);
  1021.         fCollaboratorTextListView.DelItemAt(theIndex, kOneItem);
  1022.     END;    {TEditView.DeleteCollaborator}
  1023.     
  1024. {$S MARes}
  1025. PROCEDURE TEditView.AcceptNewClassName;
  1026.  
  1027. VAR
  1028.     theEntryItemStr: Str255;
  1029.     theItem: TItem;
  1030.     
  1031. BEGIN
  1032.     fClassNameItem.GetText(theEntryItemStr);
  1033.     theItem:= fCard.GetTheClass;
  1034.     IF theEntryItemStr <> theItem.GetTheName THEN
  1035.         SELF.PostCommand(SELF.MakeChangeClassCmd);
  1036. END;
  1037.  
  1038. {$S MARes}
  1039. PROCEDURE TEditView.AcceptNewSuperClassName;
  1040.  
  1041. VAR
  1042.     theEntryItemStr: Str255;
  1043.     theItem: TItem;
  1044.     
  1045. BEGIN
  1046.     fSuperClassNameItem.GetText(theEntryItemStr);
  1047.     theItem:= fCard.GetTheSuperClass;
  1048.     IF theEntryItemStr <> theItem.GetTheName THEN
  1049.         SELF.PostCommand(SELF.MakeChangeSuperClassCmd);
  1050. END;
  1051.  
  1052. {$S MARes}
  1053.     PROCEDURE TEditView.DoChoice(origView: TView; itsChoice: INTEGER); OVERRIDE;
  1054.     
  1055.     VAR
  1056.         typeMenuItemNum: INTEGER;
  1057.         theTypeStr: str255;
  1058.         theEntryItemStr: str255;
  1059.         theItem: TItem;
  1060.     
  1061.     FUNCTION HaveEqualNames(theName: str255):BOOLEAN;
  1062.     BEGIN
  1063.         HaveEqualNames:= (theItem.GetTheName = theName);
  1064.     END;
  1065.     
  1066.     BEGIN
  1067.         IF (origView = fItemTypeMenu) OR (origView = fCollaboratorsMenu) THEN
  1068.             SELF.StuffFieldTypeEntryItem;
  1069.         IF origView = fSuperClassTypeMenu THEN
  1070.             BEGIN
  1071.               SELF.StuffSuperClassEntryItem;
  1072.                 SELF.PostCommand(SELF.MakeChangeSuperClassCmd);
  1073.             END;
  1074.         IF (itsChoice = mEditEnterKey) OR (itsChoice = mEditReturnKey) 
  1075.                 OR (itsChoice = mOKHit) THEN
  1076.           BEGIN
  1077.                 {hilite the entry, because we're staying where we are}
  1078.                 IF fCurrentEditText=fClassNameItem THEN
  1079.                     BEGIN
  1080.                         SELF.AcceptNewClassName;
  1081.                         SELF.DoSelectEditText(fClassNameItem, TRUE);
  1082.                     END;
  1083.                 IF fCurrentEditText=fSuperClassNameItem THEN
  1084.                     BEGIN
  1085.                         SELF.AcceptNewSuperClassName;
  1086.                         SELF.DoSelectEditText(fSuperClassNameItem, TRUE);
  1087.                     END;
  1088.             END;
  1089.         IF (itsChoice = mEditTextHit) OR (itsChoice = mEditTabKey) THEN
  1090.           BEGIN
  1091.                 {don't hilite the entry, because we'll move to a different field}
  1092.                 IF fCurrentEditText=fClassNameItem THEN
  1093.                     SELF.AcceptNewClassName;
  1094.                 IF fCurrentEditText=fSuperClassNameItem THEN
  1095.                     SELF.AcceptNewSuperClassName;
  1096.             END;
  1097.         IF (itsChoice = mOKHit) THEN
  1098.           BEGIN
  1099.                 {in the case of an OKHit, always check first for changes in the class/super
  1100.                  class field, then check for possible changes to the items.  This may in 
  1101.                  fact be calling Accept… for the second time this pass, but it's necessary
  1102.                  so that we can hilite everything appropriately}
  1103.                 SELF.AcceptNewClassName;
  1104.                 SELF.AcceptNewSuperClassName;
  1105.                 fFieldEntryItem.GetText(theEntryItemStr);
  1106.                 IF theEntryItemStr <> kEmptyString THEN
  1107.                     CASE fEditMode OF
  1108.                         kFieldsMode:
  1109.                             BEGIN
  1110.                                 IF fFieldTextListView.FirstSelectedItem<>0 THEN
  1111.                                     SELF.PostCommand(SELF.MakeChangeFieldCmd)
  1112.                                 ELSE
  1113.                                     SELF.PostCommand(SELF.MakeAddFieldCmd);
  1114.                             END;
  1115.                         kMethodsMode:
  1116.                             BEGIN
  1117.                                 IF fMethodTextListView.FirstSelectedItem<>0 THEN
  1118.                                     SELF.PostCommand(SELF.MakeChangeMethodCmd)
  1119.                                 ELSE
  1120.                                     SELF.PostCommand(SELF.MakeAddMethodCmd);
  1121.                             END;
  1122.                         kCollaboratorsMode:
  1123.                             BEGIN
  1124.                                 IF fCollaboratorTextListView.FirstSelectedItem<>0 THEN
  1125.                                     SELF.PostCommand(SELF.MakeChangeCollaboratorCmd)
  1126.                                 ELSE
  1127.                                     SELF.PostCommand(SELF.MakeAddCollabCmd);
  1128.                             END;
  1129.                     END; {CASE}
  1130.             END;
  1131.         IF (itsChoice = mCancelHit) THEN
  1132.             CASE fEditMode OF            {we want to clean out the entry view if we cancel}
  1133.                 kFieldsMode:
  1134.                     BEGIN
  1135.                         SELF.SetupFieldsMode;
  1136.                         SELF.DeselectFieldTextListView;
  1137.                     END;
  1138.                 kMethodsMode:
  1139.                     BEGIN
  1140.                         SELF.SetupMethodsMode;
  1141.                         SELF.DeselectMethodTextListView;
  1142.                     END;
  1143.                 kCollaboratorsMode:
  1144.                     BEGIN
  1145.                         SELF.SetupCollaboratorsMode;
  1146.                         SELF.DeselectCollaboratorTextListView;
  1147.                     END;
  1148.             END; {CASE}
  1149.         INHERITED DoChoice(origView, itsChoice);
  1150.     END;    {TEditView.DoChoice}
  1151.  
  1152.     {$S ARes}
  1153.     PROCEDURE TEditView.DeselectFieldTextListView;
  1154.     BEGIN
  1155.         fFieldTextListView.DeselectTheView;
  1156.     END;
  1157.  
  1158.     {$S ARes}
  1159.     PROCEDURE TEditView.DeselectMethodTextListView;
  1160.     BEGIN
  1161.         fMethodTextListView.DeselectTheView;
  1162.     END;
  1163.  
  1164.     {$S ARes}
  1165.     PROCEDURE TEditView.DeselectCollaboratorTextListView;
  1166.     BEGIN
  1167.         fCollaboratorTextListView.DeselectTheView;
  1168.     END;
  1169.     
  1170.     {$S ARes}
  1171.     PROCEDURE TEditView.DeactivateView;
  1172.     BEGIN
  1173.         {accept any class/superclass name changes that might have occured}
  1174.         SELF.AcceptNewClassName;
  1175.         SELF.AcceptNewSuperClassName;
  1176.     END;
  1177.     
  1178.     {$S AFields}
  1179.     PROCEDURE TEditView.Fields(PROCEDURE DoToField(
  1180.                     fieldName: Str255; fieldAddr: Ptr; fieldType: INTEGER)); OVERRIDE;
  1181.     
  1182.         
  1183.     BEGIN
  1184.         DoToField('TEditView', NIL, bClass);
  1185.         DoToField('fCard', @fCard, bObject);
  1186.         DoToField('fClassNameItem', @fClassNameItem, bObject);
  1187.         DoToField('fSuperClassNameItem', @fSuperClassNameItem, bObject);
  1188.         DoToField('fFieldEntryItem', @fFieldEntryItem, bObject);
  1189.         DoToField('fFieldTypeEntryItem', @fFieldTypeEntryItem, bObject);
  1190.         DoToField('fFieldTextListView', @fFieldTextListView, bObject);
  1191.         DoToField('fMethodTextListView', @fMethodTextListView, bObject);
  1192.         DoToField('fCollaboratorTextListView', @fCollaboratorTextListView, bObject);
  1193.         DoToField('fItemTypeMenu', @fItemTypeMenu, bObject);
  1194.         DoToField('fOVERRIDEBox', @fOVERRIDEBox, bObject);
  1195.         INHERITED Fields(DoToField);
  1196.     END;   {TEditView.Fields}
  1197.     
  1198.     
  1199.     (********************************)
  1200.     (* methods for TParenStaticText *)
  1201.     (********************************)
  1202.     
  1203.     {$S ARes}
  1204.     PROCEDURE TParenStaticText.SetText(theText: Str255; redraw: BOOLEAN); OVERRIDE;
  1205.     
  1206.     BEGIN
  1207.         theText:= Concat('(', theText, ')');
  1208.         INHERITED SetText(theText, redraw);
  1209.     END;    {TParenStaticText.SetText}
  1210.     
  1211.     
  1212.     (***************************)
  1213.     (* methods for TSimpleView *)
  1214.     (***************************)
  1215.     
  1216.     {$S ARes}
  1217.     FUNCTION TSimpleView.GetCard: TCard;
  1218.     
  1219.     BEGIN
  1220.         GetCard:= fCard;
  1221.     END;    {TSimpleView.GetCard}
  1222.     
  1223.     {$S ARes}
  1224.     PROCEDURE TSimpleView.SetCard(theCard:TCard);
  1225.     
  1226.     BEGIN
  1227.         fCard:= theCard;
  1228.     END;    {TSimpleView.SetCard}
  1229.     
  1230.     {$S ARes}
  1231.     FUNCTION TSimpleView.GetClassView: TStaticText;
  1232.     
  1233.     BEGIN
  1234.         GetClassView:= fClassTextView;
  1235.     END;    {TSimpleView.GetClassView}
  1236.     
  1237.     {$S ARes}
  1238.     PROCEDURE TSimpleView.SetClassView(theClassView:TStaticText);
  1239.     
  1240.     BEGIN
  1241.         fClassTextView:= theClassView;
  1242.     END;    {TSimpleView.SetClassView}
  1243.     
  1244.     {$S ARes}
  1245.     FUNCTION TSimpleView.GetSuperClassView: TParenStaticText;
  1246.     
  1247.     BEGIN
  1248.         GetSuperClassView:= fSuperClassTextView;
  1249.     END;    {TSimpleView.GetSuperClassView}
  1250.     
  1251.     {$S ARes}
  1252.     PROCEDURE TSimpleView.SetSuperClassView(theSuperClassView:TParenStaticText);
  1253.     
  1254.     BEGIN
  1255.         fSuperClassTextView:= theSuperClassView;
  1256.     END;    {TSimpleView.SetSuperClassView}
  1257.     
  1258.     {$S ARes}
  1259.     FUNCTION TSimpleView.GetSelected: boolean;
  1260.     
  1261.     BEGIN
  1262.         GetSelected:= fSelected;
  1263.     END;    {TSimpleView.GetSelected}
  1264.     
  1265.     {$S ARes}
  1266.     PROCEDURE TSimpleView.SetSelected(turnItOn:boolean);
  1267.     
  1268.     BEGIN
  1269.         fSelected:= turnItOn;
  1270.     END;    {TSimpleView.SetSelected}
  1271.     
  1272.     {$S ARes}
  1273.     FUNCTION TSimpleView.GetDragging: boolean;
  1274.     
  1275.     BEGIN
  1276.         GetDragging:= fDragging;
  1277.     END;    {TSimpleView.GetDragging}
  1278.     
  1279.     {$S ARes}
  1280.     PROCEDURE TSimpleView.SetDragging(turnItOn:boolean);
  1281.     
  1282.     BEGIN
  1283.         fDragging:= turnItOn;
  1284.     END;    {TSimpleView.SetDragging}
  1285.     
  1286.     {$S ARes}
  1287.     PROCEDURE TSimpleView.ISimpleView;
  1288.     
  1289.     VAR
  1290.         aStaticTextView: TStaticText;
  1291.         aParenStaticTextView: TParenStaticText;
  1292.     
  1293.     BEGIN
  1294.         aStaticTextView:= TStaticText(SELF.FindSubView(kClassNameViewID));
  1295.         SELF.SetClassView(aStaticTextView);
  1296.         
  1297.         aParenStaticTextView:= TParenStaticText(SELF.FindSubView(kSuperNameViewID));
  1298.         SELF.SetSuperClassView(aParenStaticTextView);
  1299.         
  1300.         SELF.SetSelected(kIsSelected);
  1301.     END;    {TSimpleView.ISimpleView}
  1302.     
  1303.     {$S ARes}
  1304.     PROCEDURE TSimpleView.IRes(itsDocument: TDocument; 
  1305.                          itsSuperView: TView; VAR itsParams: Ptr); OVERRIDE;
  1306.                          
  1307.     VAR
  1308.         ourDesignDoc: TDesignDocument;
  1309.         ourCard: TCard;
  1310.         
  1311.     BEGIN
  1312.         INHERITED IRes(itsDocument, itsSuperView, itsParams);
  1313.         
  1314.         ourDesignDoc:= TDesignDocument(itsDocument);
  1315.         ourCard:= ourDesignDoc.GetCurrentCard;
  1316.         SELF.SetCard(ourCard);
  1317.     END;    {TSimpleView.IRes}
  1318.     
  1319.     {$S ADoCommand}
  1320.     PROCEDURE TSimpleView.ChangeClassName(theName: str255);
  1321.     
  1322.     BEGIN
  1323.         fClassTextView.SetText(theName, kReDraw);
  1324.     END;    {TSimpleView.ChangeClassName}
  1325.     
  1326.     {$S ADoCommand}
  1327.     PROCEDURE TSimpleView.ChangeSuperClassName(theName: str255);
  1328.     
  1329.     BEGIN
  1330.         fSuperClassTextView.SetText(theName, kReDraw);
  1331.     END;    {TSimpleView.ChangeSuperClassName}
  1332.     
  1333.     {$S ARes}
  1334.     PROCEDURE TSimpleView.OpenEditView;
  1335.     
  1336.     VAR
  1337.         ourDocument: TDesignDocument;
  1338.         aCardWindow: TCardWindow;
  1339.         anEditDialog: TEditView;
  1340.     
  1341.     BEGIN
  1342.         IF fCard.GetEditView = NIL THEN
  1343.             BEGIN
  1344.                 {writeln('first time');}
  1345.                 ourDocument:= fCard.GetDocument;
  1346.                 aCardWindow := TCardWindow(NewTemplateWindow(kEditViewID, ourDocument));
  1347.                 anEditDialog := TEditView(aCardWindow.FindSubView(kEditViewNameID));
  1348.                 anEditDialog.IEditView(fCard);    {had to do this here to get card}
  1349.                 fCard.SetEditView(anEditDialog);
  1350.                 aCardWindow.ICardWindow(anEditDialog);
  1351.                 {writeln('before open');}
  1352.                 aCardWindow.Open;
  1353.                 {writeln('after open');}
  1354.             END
  1355.         ELSE
  1356.             BEGIN
  1357.                 {writeln('second time');}
  1358.                 anEditDialog:= fCard.GetEditView;
  1359.                 aCardWindow:= TCardWindow(anEditDialog.GetWindow);
  1360.                 aCardWindow.Show(true, true);
  1361.                 aCardWindow.Select;
  1362.             END;
  1363.     END;
  1364.                         
  1365.     {$S ASelCommand}    
  1366.     FUNCTION  TSimpleView.DoMouseCommand(VAR theMouse: Point;
  1367.                 VAR info: EventInfo; VAR hysteresis: Point): TCommand; OVERRIDE;
  1368.     
  1369.     VAR
  1370.         ourDocument: TDesignDocument;
  1371.         aDragger: TDraggerCommand;
  1372.         
  1373.     BEGIN
  1374.         DoMouseCommand:= gNoChanges;
  1375.         CASE info.theClickCount OF
  1376.             kOneClick:
  1377.                 BEGIN
  1378.                     ourDocument:= fCard.GetDocument;
  1379.                     ourDocument.SetCurrentCard(fCard);
  1380.                     NEW(aDragger);
  1381.                     FailNIL(aDragger);
  1382.                     aDragger.IDraggerCommand(SELF, theMouse);
  1383.                     DoMouseCommand:= aDragger;
  1384.                 END;
  1385.             kTwoClicks:    SELF.OpenEditView;
  1386.             OTHERWISE
  1387.                 {do nothing};
  1388.         END;    {CASE}
  1389.     END;    {TSimpleView.DoMouseCommand}
  1390.     
  1391.     {$S ARes}
  1392.     PROCEDURE TSimpleView.DoHighlightSelection(fromHL, toHL: HLState); OVERRIDE;
  1393.     
  1394.     VAR
  1395.         theIcon:            TIcon;
  1396.         
  1397.     PROCEDURE OutLineView(theColor: LONGINT);
  1398.     
  1399.         VAR
  1400.             itsQDExtent:    Rect;
  1401.     
  1402.         BEGIN
  1403.             PenNormal;
  1404.             ForeColor(theColor);
  1405.             PenSize(1, 1);
  1406.             SetRect(itsQDExtent, 0, 0, SELF.fSize.h, SELF.fSize.v);
  1407.             FrameRect(itsQDExtent);
  1408.         END;
  1409.     
  1410.     BEGIN
  1411.         IF fSelected THEN
  1412.             BEGIN
  1413.                 theIcon:= TIcon(SELF.FindSubView(kIconViewID));
  1414.                 FailNIL(theIcon);
  1415.                 
  1416.                 IF (fromHL = hlOff) AND (toHL = hlOn) THEN
  1417.                     theIcon.HiliteState(kHiLite, kReDraw);
  1418.                 
  1419.                 IF (fromHL = hlOff) AND (toHL = hlDim) THEN
  1420.                     BEGIN
  1421.                         OutLineView(blackColor);
  1422.                         theIcon.HiliteState(NOT(kHilite), kReDraw);
  1423.                         theIcon.DimState(kDim, kReDraw);
  1424.                     END;
  1425.                     
  1426.                 IF (fromHL = hlOn) AND (toHL = hlOff) THEN
  1427.                     theIcon.HiliteState(NOT(kHiLite), kReDraw);
  1428.                 
  1429.                 IF (fromHL = hlOn) AND (toHL = hlDim) THEN
  1430.                     BEGIN
  1431.                         OutLineView(blackColor);
  1432.                         theIcon.HiliteState(NOT(kHilite), kReDraw);
  1433.                         theIcon.DimState(kDim, kReDraw);
  1434.                     END;
  1435.                 
  1436.                 IF (fromHL = hlDim) AND (toHL = hlOn) THEN
  1437.                     BEGIN
  1438.                         OutLineView(whiteColor);
  1439.                         theIcon.HiliteState(kHilite, kReDraw);
  1440.                         theIcon.DimState((NOT kDim), kReDraw);
  1441.                     END;
  1442.                 
  1443.                 IF (fromHL = hlDim) AND (toHL = hlOff) THEN
  1444.                     BEGIN
  1445.                         OutLineView(whiteColor);
  1446.                         theIcon.HiliteState((NOT kHilite), kReDraw);
  1447.                         theIcon.DimState((NOT kDim), kReDraw);
  1448.                     END;
  1449.             END;
  1450.     END;    {TSimpleView.DoHighlightSelection}
  1451.     
  1452.     {$S AFields}
  1453.     PROCEDURE TSimpleView.Fields(PROCEDURE DoToField(fieldName: Str255; fieldAddr: Ptr; 
  1454.         fieldType: INTEGER)); OVERRIDE;
  1455.     
  1456.     BEGIN
  1457.         DoToField('TSimpleView', NIL, bClass);
  1458.         DoToField('fCard', @fCard, bObject);
  1459.         DoToField('fClassTextView', @fClassTextView, bObject);
  1460.         DoToField('fSuperClassTextView', @fSuperClassTextView, bObject);
  1461.         DoToField('fSelected', @fSelected, bBoolean);
  1462.         DoToField('fDragging', @fDragging, bBoolean);
  1463.         INHERITED Fields(DoToField);
  1464.     END;    {TSimpleView.Fields}
  1465.     
  1466.     
  1467.     (*****************************)
  1468.     (* methods for TCardWindow     *)
  1469.     (*****************************)
  1470.     
  1471.     {$S AOpen}
  1472.     PROCEDURE TCardWindow.ICardWindow(theEditView: TEditView);
  1473.     
  1474.     BEGIN
  1475.     {    writeln('IN TCardWindow.ICardWindow');}
  1476.         fEditView:=theEditView;
  1477.         {writeln('Done w/ TCardWindow.ICardWindow');}
  1478.     END;
  1479.     
  1480.     {$S AOpen}
  1481.     PROCEDURE TCardWindow.Activate(entering : Boolean); OVERRIDE;
  1482.     
  1483.     BEGIN
  1484.         {writeln('in activate');}
  1485.         IF NOT entering THEN
  1486.             fEditView.DeactivateView;
  1487.         {writeln('inherited activate');}
  1488.         INHERITED Activate(entering);
  1489.     END;
  1490.         
  1491.     (**************************)
  1492.     (* methods for TNewButton *)
  1493.     (**************************)
  1494.     {$ARes}
  1495.     FUNCTION TNewButton.GetEditView: TEditView;
  1496.     BEGIN
  1497.         GetEditView:= fEditView;
  1498.     END;
  1499.  
  1500.     {$ARes}
  1501.     PROCEDURE TNewButton.SetEditView(theEditView: TEditView);
  1502.     BEGIN
  1503.         fEditView:=theEditView;
  1504.     END;
  1505.     
  1506.     {$AOpen}
  1507.     PROCEDURE TNewButton.INewButton(theEditView: TEditView);
  1508.     BEGIN
  1509.         SELF.SetEditView(theEditView);
  1510.     END;
  1511.  
  1512.     {$ASelCommand}
  1513.     PROCEDURE TNewButton.DoChoice(origView: TView; itsChoice: INTEGER); OVERRIDE;
  1514.  
  1515.     BEGIN
  1516.         INHERITED DoChoice(origView, itsChoice);
  1517.         fEditView.DeselectFieldTextListView;
  1518.         fEditView.DeselectMethodTextListView;
  1519.         fEditView.DeselectCollaboratorTextListView;
  1520.     END;
  1521.     
  1522.     {$ASelCommand}
  1523.     PROCEDURE TNewFieldButton.DoChoice(origView: TView; itsChoice: INTEGER); OVERRIDE;
  1524.  
  1525.     BEGIN
  1526.         INHERITED DoChoice(origView, itsChoice);
  1527.         SELF.GetEditView.SetUpFieldsMode;
  1528.     END;
  1529.     
  1530.     {$ASelCommand}
  1531.     PROCEDURE TNewMethodButton.DoChoice(origView: TView; itsChoice: INTEGER); OVERRIDE;
  1532.  
  1533.     BEGIN
  1534.         INHERITED DoChoice(origView, itsChoice);
  1535.         SELF.GetEditView.SetUpMethodsMode;
  1536.     END;
  1537.     
  1538.     {$ASelCommand}
  1539.     PROCEDURE TNewCollaboratorButton.DoChoice(origView: TView; itsChoice: INTEGER); OVERRIDE;
  1540.  
  1541.     BEGIN
  1542.         INHERITED DoChoice(origView, itsChoice);
  1543.         SELF.GetEditView.SetUpCollaboratorsMode;
  1544.     END;
  1545.     
  1546.     (*****************************)
  1547.     (* methods for TAcceptButton *)
  1548.     (*****************************)
  1549.     {$AOpen}
  1550.     PROCEDURE TAcceptButton.IRes(itsDocument: TDocument; itsSuperView: TView;
  1551.                                                                 VAR itsParams: Ptr); OVERRIDE;
  1552.     BEGIN
  1553.         INHERITED IRes(itsDocument, itsSuperView, itsParams);
  1554.         fDefChoice:= mOKHit;
  1555.     END;
  1556.     
  1557.     (*****************************)
  1558.     (* methods for TCancelButton *)
  1559.     (*****************************)
  1560.     {$AOpen}
  1561.     PROCEDURE TCancelButton.IRes(itsDocument: TDocument; itsSuperView: TView;
  1562.                                                              VAR itsParams: Ptr); OVERRIDE;
  1563.     BEGIN
  1564.         INHERITED IRes(itsDocument, itsSuperView, itsParams);
  1565.         fDefChoice:= mCancelHit;
  1566.     END;
  1567.     
  1568.     (*****************************)
  1569.     (* methods for TTextListView *)
  1570.     (*****************************)
  1571.     
  1572.     {$S ARes}
  1573.     FUNCTION TMyTextListView.GetEditView: TEditView;
  1574.     
  1575.     BEGIN
  1576.         GetEditView:= fEditView;
  1577.     END;    {TMyTextListView.GetEditView}
  1578.     
  1579.     {$S ARes}
  1580.     PROCEDURE TMyTextListView.SetEditView(theEditView:TEditView);
  1581.     
  1582.     BEGIN
  1583.         fEditView:= theEditView;
  1584.     END;    {TMyTextListView.SetEditView}
  1585.     
  1586.     {$S ARes}
  1587.     FUNCTION TMyTextListView.GetItemList: TMyList;
  1588.     
  1589.     BEGIN
  1590.         GetItemList:= fItemList;
  1591.     END;    {TMyTextListView.GetItemList}
  1592.     
  1593.     {$S ARes}
  1594.     PROCEDURE TMyTextListView.SetItemList(theList:TMyList);
  1595.     
  1596.     BEGIN
  1597.         fItemList:= theList;
  1598.     END;    {TMyTextListView.SetItemList}
  1599.     
  1600.     {$S ARes}
  1601.     PROCEDURE TMyTextListView.GetItemText(anItem: INTEGER; VAR aString: Str255); OVERRIDE;
  1602.     
  1603.     VAR
  1604.         ourItem: TItem;
  1605.     
  1606.     BEGIN
  1607.         ourItem:= TItem(fItemList.At(anItem));
  1608.         aString:= ourItem.GetTheItem;
  1609.     END;    {TMyTextListView.GetItemText}
  1610.     
  1611.     {$S ARes}
  1612.     FUNCTION TMyTextListView.GetNumRows: integer;
  1613.     
  1614.     BEGIN
  1615.         GetNumRows:= fNumOfRows;
  1616.     END;    {TMyTextListView.GetNumRows}
  1617.  
  1618.     {$S Ares}
  1619.     PROCEDURE TMyTextListView.DeselectTheView;
  1620.  
  1621.     BEGIN
  1622.         IF SELF.Focus THEN ;
  1623.         {write(SELF.FirstSelectedItem);}
  1624.         SELF.SelectItem(SELF.FirstSelectedItem,kDontExtendSel,kHiLite,kDontSelect);
  1625.         {write('.');}
  1626.     END; {TMyTextListView.DeselectTheView}
  1627.     
  1628.     {$S ARes}
  1629.     PROCEDURE TMyTextListView.StuffTheItemEditView(theItemNumber:INTEGER);
  1630.  
  1631.         BEGIN
  1632.             ProgramBreak('TMyTextListView.StuffTheItemEditView');
  1633.         END;
  1634.  
  1635.     {$S ARes}
  1636.     PROCEDURE TMyTextListView.UpdateTheItem(theWindow: TWindow; theItem: TItem);
  1637.  
  1638.         BEGIN
  1639.             ProgramBreak('TMyTextListView.UpdateTheItem');
  1640.         END;
  1641.  
  1642.     {$S ARes}
  1643.     FUNCTION TMyTextListView.GetTheItemToEdit(theItemNumber:INTEGER): TItem;
  1644.  
  1645.         BEGIN
  1646.             {writeln(FirstSelectedItem);}
  1647.             GetTheItemToEdit:=TItem(SELF.GetItemList.At(theItemNumber));
  1648.         END;
  1649.  
  1650.     {$S ARes}
  1651.     PROCEDURE TMyTextListView.SetEditField(kNameField: IDType; aString: Str255; 
  1652.                 aWindow: TWindow);
  1653.         VAR
  1654.             theEditText: TEditText;
  1655.             
  1656.         BEGIN
  1657.             theEditText:=TEditText(aWindow.FindSubview(kNameField));
  1658.             theEditText.SetText(aString, TRUE);
  1659.         END;
  1660.         
  1661.     {$S ARes}
  1662.     FUNCTION TMyTextListView.GetEditField(kNameField: IDType; aWindow: TWindow): Str255;
  1663.         VAR
  1664.             theEditText: TEditText;
  1665.             aString: Str255;
  1666.             
  1667.         BEGIN
  1668.             theEditText:=TEditText(aWindow.FindSubview(kNameField));
  1669.             theEditText.GetText(aString);
  1670.             GetEditField:=aString;
  1671.         END;
  1672.         
  1673. {$S AFields}
  1674.     PROCEDURE TMyTextListView.Fields(PROCEDURE DoToField(fieldName: Str255; fieldAddr: Ptr; 
  1675.         fieldType: INTEGER)); OVERRIDE;
  1676.     
  1677.         BEGIN
  1678.             DoToField('TMyTextListView', NIL, bClass);
  1679.             DoToField('fItemList', @fItemList, bObject);
  1680.             INHERITED Fields(DoToField);
  1681.         END;    {TMyTextListView.Fields}
  1682.     
  1683.     {---------- Methods for TMethodTextListView ----------}
  1684.  
  1685.     {$S ARes}
  1686.     PROCEDURE TMethodTextListView.StuffTheItemEditView(theItemNumber:INTEGER); OVERRIDE;
  1687.  
  1688.         VAR 
  1689.             aMethodItem: TMethodItem;
  1690.             aString: Str255;
  1691.             theEditView: TEditView;
  1692.             
  1693.         BEGIN
  1694.             aMethodItem:= TMethodItem(SELF.GetTheItemToEdit(theItemNumber));
  1695.             theEditView:=SELF.GetEditView;
  1696.             aString:= aMethodItem.GetTheItem;
  1697.             theEditView.GetFieldEntryView.SetText(aString, kRedraw);
  1698.             theEditView.SetOVERRIDE(aMethodItem.GetOVERRIDE);
  1699.             theEditView.DoSelectEditText(theEditView.GetFieldEntryView, TRUE);
  1700.         END;
  1701.  
  1702.     {$S ARes}
  1703.     PROCEDURE TMethodTextListView.SelectItem(anitem: INTEGER; 
  1704.                                             extendSelection, highlight, select: BOOLEAN); OVERRIDE;
  1705.     BEGIN
  1706.         INHERITED SelectItem(anItem, extendSelection, highlight, select);
  1707.         IF select THEN 
  1708.             SELF.StuffTheItemEditView(anitem);
  1709.     END;
  1710.     
  1711.     {$S ARes}
  1712.     PROCEDURE TMethodTextListView.UpdateTheItem(theWindow: TWindow; theItem: TItem); OVERRIDE;
  1713.  
  1714.         BEGIN
  1715.             ProgramBreak('TMethodTextListView.UpdateTheItem');
  1716.         END;
  1717.  
  1718. {$S ARes}    
  1719. FUNCTION TMethodTextListView.DoMouseCommand(VAR theMouse: Point;
  1720.                                           VAR info: EventInfo;
  1721.                                           VAR hysteresis: Point): TCommand; OVERRIDE;
  1722.  
  1723.     BEGIN
  1724.         DoMouseCommand:= INHERITED DoMouseCommand(theMouse, info, hysteresis);
  1725.         CASE info.theClickCount OF
  1726.             kOneClick:
  1727.                 BEGIN
  1728.                     SELF.GetEditView.DeselectFieldTextListView;
  1729.                     SELF.GetEditView.DeselectCollaboratorTextListView;
  1730.                     SELF.GetEditView.SetUpMethodsMode;
  1731.                     IF SELF.Focus THEN ;
  1732.                 END;
  1733.             OTHERWISE
  1734.                 {do nothing};
  1735.         END; {CASE}
  1736.     END; {TMethodTextListView.DoMouseCommand}
  1737.  
  1738.     {---------- Methods for TModalTextListView ----------}
  1739.  
  1740.     {$S ARes}
  1741.     PROCEDURE TModalTextListView.StuffTheItemEditView(theItemNumber:INTEGER); OVERRIDE;
  1742.  
  1743.         VAR 
  1744.             aItem: TItem;
  1745.             aString: Str255;
  1746.             theEditView: TEditView;
  1747.             
  1748.         BEGIN
  1749.             aItem:= SELF.GetTheItemToEdit(theItemNumber);
  1750.             theEditView:=SELF.GetEditView;
  1751.             aString:= TFieldItem(aItem).GetTheItem;
  1752.             theEditView.GetFieldEntryView.SetText(aString, kRedraw);
  1753.             aString:= TFieldItem(aItem).GetItemType;
  1754.             theEditView.GetTypeEntryView.SetText(aString, kRedraw);
  1755.             theEditView.DoSelectEditText(theEditView.GetFieldEntryView, TRUE);
  1756.         END;
  1757.  
  1758.     {$S ARes}
  1759.     PROCEDURE TModalTextListView.UpdateTheItem(theWindow: TWindow; theItem: TItem); OVERRIDE;
  1760.         VAR
  1761.             aString: Str255;
  1762.             
  1763.         BEGIN
  1764.             aString:=GetEditField(kTypeField,theWindow);
  1765.             TFieldItem(theItem).SetItemType(aString);
  1766.             aString:=GetEditField(kNameField,theWindow);
  1767.             TFieldItem(theItem).SetTheName(aString);
  1768.         END;
  1769.  
  1770. {---------- Methods for TCollaboratorTextListView ----------}
  1771.  
  1772. {$S ARes}
  1773. PROCEDURE TCollaboratorTextListView.SelectItem(anitem: INTEGER; 
  1774.                                         extendSelection, highlight, select: BOOLEAN); OVERRIDE;
  1775. BEGIN
  1776.     INHERITED SelectItem(anItem, extendSelection, highlight, select);
  1777.     IF select THEN 
  1778.         SELF.StuffTheItemEditView(anitem);
  1779. END;
  1780.     
  1781. {$S ARes}    
  1782. FUNCTION TCollaboratorTextListView.DoMouseCommand(VAR theMouse: Point;
  1783.                                           VAR info: EventInfo;
  1784.                                           VAR hysteresis: Point): TCommand; OVERRIDE;
  1785.  
  1786.     BEGIN
  1787.         DoMouseCommand:= INHERITED DoMouseCommand(theMouse, info, hysteresis);
  1788.         CASE info.theClickCount OF
  1789.             kOneClick:
  1790.                 BEGIN
  1791.                     SELF.GetEditView.DeselectFieldTextListView;
  1792.                     SELF.GetEditView.DeselectMethodTextListView;
  1793.                     SELF.GetEditView.SetUpCollaboratorsMode;
  1794.                     IF SELF.Focus THEN ;
  1795.                 END;
  1796.             OTHERWISE
  1797.                 {do nothing};
  1798.         END; {CASE}
  1799.     END; {TCollaboratorTextListView.DoMouseCommand}
  1800.  
  1801.     {---------- Methods for TFieldTextListView ----------}
  1802.  
  1803. {$S ARes}
  1804. PROCEDURE TFieldTextListView.SelectItem(anitem: INTEGER; 
  1805.                                         extendSelection, highlight, select: BOOLEAN); OVERRIDE;
  1806. BEGIN
  1807.     INHERITED SelectItem(anItem, extendSelection, highlight, select);
  1808.     IF select THEN 
  1809.         SELF.StuffTheItemEditView(anitem);
  1810. END;
  1811.     
  1812. {$S ARes}    
  1813. FUNCTION TFieldTextListView.DoMouseCommand(VAR theMouse: Point;
  1814.                                           VAR info: EventInfo;
  1815.                                           VAR hysteresis: Point): TCommand; OVERRIDE;
  1816.  
  1817.     BEGIN
  1818.         DoMouseCommand:= INHERITED DoMouseCommand(theMouse, info, hysteresis);
  1819.         CASE info.theClickCount OF
  1820.             kOneClick:
  1821.                 BEGIN
  1822.                     SELF.GetEditView.DeselectCollaboratorTextListView;
  1823.                     SELF.GetEditView.DeselectMethodTextListView;
  1824.                     SELF.GetEditView.SetUpFieldsMode;
  1825.                     IF SELF.Focus THEN ;
  1826.                 END;
  1827.             OTHERWISE
  1828.                 {do nothing};
  1829.         END; {CASE}
  1830.     END; {TFieldTextListView.DoMouseCommand}
  1831.  
  1832.     (*************************)
  1833.     (* methods for TMyTEView *)
  1834.     (*************************)
  1835.     
  1836.     {$S ARes}
  1837.     FUNCTION TMyTEView.GetDesignDoc: TDesignDocument;
  1838.     
  1839.         BEGIN
  1840.             GetDesignDoc:= fDesignDocument;
  1841.         END;    {TMyTEView.GetDesignDoc}
  1842.     
  1843.     {$S ARes}
  1844.     PROCEDURE TMyTEView.SetDesignDoc(theDesignDoc: TDesignDocument);
  1845.     
  1846.     BEGIN
  1847.         fDesignDocument:= theDesignDoc;
  1848.     END;    {TMyTEView.SetDesignDoc}
  1849.     
  1850.     {$S ARes}
  1851.     PROCEDURE TMyTEView.DesignDocumentIsGone;
  1852.     
  1853.         BEGIN
  1854.             SELF.SetDesignDoc(NIL);
  1855.             TMPWTextDocument(fDocument).SetDesignDoc(NIL);
  1856.         END;    {TMyTEView.DesignDocumentIsGone}
  1857.     
  1858.     {$S ARes}
  1859.     PROCEDURE TMyTEView.ClearText;
  1860.     
  1861.     BEGIN
  1862.         TESetSelect(kBeginning, kEnd, fHTE);
  1863.         TEDelete(fHTE);
  1864.     END;    {TMyTEView.ClearText}
  1865.     
  1866.     {$S ARes}
  1867.     PROCEDURE TMyTEView.WriteToMyTEView(theString: str255);
  1868.         
  1869.     BEGIN
  1870.         IF SELF.Focus THEN;
  1871.         TEInsert(@theString[1], Length(theString), fHTE);
  1872.     END;    {TMyTEView.WriteToMyTEView}
  1873.     
  1874.     {$S ARes}
  1875.     PROCEDURE TMyTEView.WriteEndOfLine;
  1876.     
  1877.     VAR
  1878.         TextLength: INTEGER;
  1879.         
  1880.     BEGIN
  1881.         SELF.WriteToMyTEView(gEndOfLineStr);
  1882.         TextLength:= GetHandleSize(fText);
  1883.         TESetSelect(TextLength - 1, TextLength, fHTE);
  1884.         TEDelete(fHTE);
  1885.     END;    {TMyTEView.WriteEndOfLine}
  1886.     
  1887.     {$S ARes}
  1888.     PROCEDURE TMyTEView.FinishWriteOperation;
  1889.     
  1890.     VAR
  1891.         aScroller: TScroller;
  1892.     
  1893.     BEGIN
  1894.         SELF.SynchView(NOT kReDraw);
  1895.         aScroller:= SELF.GetScroller(kUseImmediateSuperView);
  1896.         IF aScroller <> NIL THEN
  1897.             aScroller.ScrollTo(kBeginning, kBeginning, kReDraw);
  1898.         TMPWTextDocument(fDocument).SetDocText(fText);
  1899.         fDocument.SetChangeCount(fDocument.GetChangeCount + 1);
  1900.     END;    {TMyTEView.FinishWriteOperation}
  1901.     
  1902.     {$S AFields}
  1903.     PROCEDURE TMyTEView.Fields(PROCEDURE DoToField(fieldName: Str255; fieldAddr: Ptr; 
  1904.         fieldType: INTEGER)); OVERRIDE;
  1905.         
  1906.         BEGIN
  1907.             DoToField('TMyTEView', NIL, bClass);
  1908.             DoToField('fDesignDocument', @fDesignDocument, bObject);
  1909.             INHERITED Fields(DoToField);
  1910.         END;    {TMyTEView.Fields}
  1911.         
  1912.  
  1913.